// 数字格式化工具函数

/**
 * 格式化数字为千分位
 * @param {number} num 要格式化的数字
 * @param {number} decimals 小数位数
 * @param {string} decimalSeparator 小数分隔符
 * @param {string} thousandsSeparator 千分位分隔符
 * @returns {string} 格式化后的字符串
 */
export function formatNumber(num, decimals = 2, decimalSeparator = '.', thousandsSeparator = ',') {
  if (num === null || num === undefined || isNaN(num)) {
    return '0'
  }

  const number = Number(num)
  const fixed = number.toFixed(decimals)
  const parts = fixed.split('.')
  
  // 添加千分位分隔符
  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, thousandsSeparator)
  
  return parts.join(decimalSeparator)
}

/**
 * 格式化为货币
 * @param {number} num 数字
 * @param {string} currency 货币符号
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的货币字符串
 */
export function formatCurrency(num, currency = '¥', decimals = 2) {
  const formatted = formatNumber(num, decimals)
  return `${currency}${formatted}`
}

/**
 * 格式化为百分比
 * @param {number} num 数字（0-1之间或0-100之间）
 * @param {number} decimals 小数位数
 * @param {boolean} isDecimal 是否为小数形式（0-1之间）
 * @returns {string} 格式化后的百分比字符串
 */
export function formatPercentage(num, decimals = 2, isDecimal = true) {
  if (num === null || num === undefined || isNaN(num)) {
    return '0%'
  }

  const number = Number(num)
  const percentage = isDecimal ? number * 100 : number
  return `${formatNumber(percentage, decimals)}%`
}

/**
 * 格式化大数字（K, M, B等）
 * @param {number} num 数字
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的字符串
 */
export function formatLargeNumber(num, decimals = 1) {
  if (num === null || num === undefined || isNaN(num)) {
    return '0'
  }

  const number = Math.abs(Number(num))
  const sign = Number(num) < 0 ? '-' : ''
  
  if (number >= 1e12) {
    return sign + formatNumber(number / 1e12, decimals) + 'T'
  } else if (number >= 1e9) {
    return sign + formatNumber(number / 1e9, decimals) + 'B'
  } else if (number >= 1e6) {
    return sign + formatNumber(number / 1e6, decimals) + 'M'
  } else if (number >= 1e3) {
    return sign + formatNumber(number / 1e3, decimals) + 'K'
  } else {
    return sign + formatNumber(number, decimals)
  }
}

/**
 * 格式化文件大小
 * @param {number} bytes 字节数
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的文件大小字符串
 */
export function formatFileSize(bytes, decimals = 2) {
  if (bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return formatNumber(bytes / Math.pow(k, i), decimals) + ' ' + sizes[i]
}

/**
 * 数字动画函数
 * @param {number} start 起始值
 * @param {number} end 结束值
 * @param {number} duration 动画时长（毫秒）
 * @param {function} callback 回调函数
 * @param {function} easing 缓动函数
 */
export function animateNumber(start, end, duration, callback, easing = easeOutQuart) {
  const startTime = Date.now()
  const change = end - start
  
  function update() {
    const currentTime = Date.now()
    const elapsed = currentTime - startTime
    const progress = Math.min(elapsed / duration, 1)
    
    const easedProgress = easing(progress)
    const currentValue = start + change * easedProgress
    
    callback(currentValue)
    
    if (progress < 1) {
      requestAnimationFrame(update)
    } else {
      callback(end) // 确保最终值准确
    }
  }
  
  requestAnimationFrame(update)
}

/**
 * 缓动函数 - easeOutQuart
 * @param {number} t 进度（0-1）
 * @returns {number} 缓动后的进度
 */
export function easeOutQuart(t) {
  return 1 - Math.pow(1 - t, 4)
}

/**
 * 缓动函数 - easeInOutCubic
 * @param {number} t 进度（0-1）
 * @returns {number} 缓动后的进度
 */
export function easeInOutCubic(t) {
  return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2
}

/**
 * 缓动函数 - easeOutBounce
 * @param {number} t 进度（0-1）
 * @returns {number} 缓动后的进度
 */
export function easeOutBounce(t) {
  const n1 = 7.5625
  const d1 = 2.75
  
  if (t < 1 / d1) {
    return n1 * t * t
  } else if (t < 2 / d1) {
    return n1 * (t -= 1.5 / d1) * t + 0.75
  } else if (t < 2.5 / d1) {
    return n1 * (t -= 2.25 / d1) * t + 0.9375
  } else {
    return n1 * (t -= 2.625 / d1) * t + 0.984375
  }
}

/**
 * 计算数字变化趋势
 * @param {number} current 当前值
 * @param {number} previous 之前的值
 * @returns {object} 趋势信息
 */
export function calculateTrend(current, previous) {
  if (previous === 0 || previous === null || previous === undefined) {
    return {
      direction: current > 0 ? 'up' : current < 0 ? 'down' : 'neutral',
      percentage: 0,
      change: current
    }
  }
  
  const change = current - previous
  const percentage = (change / Math.abs(previous)) * 100
  
  return {
    direction: change > 0 ? 'up' : change < 0 ? 'down' : 'neutral',
    percentage: Math.abs(percentage),
    change: change
  }
}

/**
 * 验证数字是否有效
 * @param {any} value 要验证的值
 * @returns {boolean} 是否为有效数字
 */
export function isValidNumber(value) {
  return value !== null && value !== undefined && !isNaN(Number(value)) && isFinite(Number(value))
}

/**
 * 安全的数字转换
 * @param {any} value 要转换的值
 * @param {number} defaultValue 默认值
 * @returns {number} 转换后的数字
 */
export function safeNumber(value, defaultValue = 0) {
  return isValidNumber(value) ? Number(value) : defaultValue
}

/**
 * 数字范围限制
 * @param {number} value 值
 * @param {number} min 最小值
 * @param {number} max 最大值
 * @returns {number} 限制后的值
 */
export function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max)
}

/**
 * 生成随机数
 * @param {number} min 最小值
 * @param {number} max 最大值
 * @param {number} decimals 小数位数
 * @returns {number} 随机数
 */
export function randomNumber(min = 0, max = 100, decimals = 0) {
  const random = Math.random() * (max - min) + min
  return decimals > 0 ? Number(random.toFixed(decimals)) : Math.floor(random)
}